This stack contains information about, and demos of, CompileIt! 2.1 — The XCMD Development System. The CompileIt! Working Model is a seperate stack that should be enclosed with this stack. You can access it through the button entitled “Working Model” above or through the “Open Stack...” menu item from the “File” menu if it is not in the same folder as this stack.
  On-line help and example scripts are available in the Working Model stack. When in the Working Model there will be a menu entitled “CompileIt!” on the menu bar. The last two items on that menu will take you to either the on-line help or the examples
  This stack and the CompileIt! 2.1 Working Model are copyrighted works. You may freely distribute them provided that: 1) You only distribute both stacks together and do not modify them, 2) You do not charge for them other than reasonable copying charges (reasonable is defined as $10 or less, online services may charge their normal online fees but may not charge a surcharge on the download of this set of stacks), and 3) you preserve all copyright and trademark information. If you wish to include the Working Model with a commercial product you will need to contact Heizer Software at 510/943-7667 for permission.
  CompileIt!, DebugIt!, Dialoger, WindowScript, and MasterScript are trademarks of Heizer Software. HyperCard, HyperTalk, Macintosh, SANE, Balloon Help, and Inside Macintosh are registered trademarks of Apple Computer, Inc. SuperCard and SuperTalk are trademarks of Silicon Beach Software. All other brand or product names are trademarks or registered trademarks of their respective companies.</text>
</content>
<content>
<layer>card</layer>
<id>12</id>
<text><span class="style1">1992 Heizer Software. All Rights Reserved. CompileIt! & Debugit! are trademarks of Heizer Software.</span></text>
CompileIt!™, the first HyperTalk® compiler, is a complete development system for the creation of external commands and functions (XCMDs/XFCNs).
Externals are used to expand the capabilities of products such as HyperCard® and Silicon Beach Software SuperCard. Prior to CompileIt!, developers had to use languages such as C or Pascal to create externals. CompileIt! makes it possible for many more users to create externals by compiling easy-to-write HyperTalk. Advanced users will find all the power they are used to as well — CompileIt! supports the Macintosh® ROM Toolbox, System 7.0, the extended XCMD interface in HyperCard 2.0, SuperCard 1.5 language and callback extensions, user-defined symbols, and much more.
FOUR REASONS FOR USING COMPILEIT!
1. Expand the capabilities of your HyperCard scripts. Use
CompileIt! and the ROM Toolbox extensions to add new
capabilities to HyperCard and similar products.
2. Increase the speed of routines written in HyperTalk.
Generally, transforming scripts into externals will give
you significant speed enhancements.
3. Protect sensitive program code from the prying eyes of
others. HyperCard is ΓÇ£openΓÇ¥, meaning that others can
read your programs and copy them. Compiled code is
not open to this kind of use.
4. Learn Macintosh programming. If you are learning how
to program the Macintosh, CompileIt! can serve as an
entry point; allowing you to easily explore the ROM
Toolbox. Later, you can ΓÇ£graduateΓÇ¥ to writing stand-
alone applications in other development systems.
HyperCard 1.2.5, HyperCard 2.x, and SuperCard are fully supported and CompileIt! can run in all three environments.
CompileIt! is not copy protected and no runtime fees or licenses are required to distribute externals created with CompileIt!.
Heizer Software provides technical support via phone and FAX and maintains a presence on several on-line services as well.
CompileIt! is fast, easy-to-use, and very powerful. With features for both the intermediate HyperTalk scripter and professional programmer alike, CompileIt! is the only development system you'll need for developing externals.
BUT DON'T JUST TAKE OUR WORD FOR IT - enclosed with this stack is a functional, working model of CompileIt! that actually makes XCMDs and XFCNs; seeing is believing! Take some time now to play with the working model, the button entitled ΓÇ£Working ModelΓÇ¥ above will take you there. The on-line help (available in the working model from both the first card and from the ΓÇ£CompileIt!ΓÇ¥ menu on the menu bar) is complete and the examples card in the working model has several scripts that are ready to be compiled. If you have System 7.0, Balloon HelpΓäó is available, just turn on the ΓÇ£Show BalloonsΓÇ¥ menu item in the ΓÇ£HelpΓÇ¥ menu (if you don't have System 7.0, option-click any object for pop-up help).
The Working Model has these limitations: 1) Only scripts of ten lines or less can be compiled. 2) DebugIt! is not available (see ΓÇ£What is DebugIt!ΓÇ¥) for a demo. 3) The symbol tables cannot be modified (the on-line help explains what the symbol tables are).
If you want the full version of CompileIt! 2.0, complete with DebugIt! and a comprehensive user manual, click on the ΓÇ£How To OrderΓÇ¥ button above.
TECHNICAL SPECIFICATIONS
System Requirements: Any Macintosh with a hard disk that can run HyperCard 1.2.5 or above. One megabyte of RAM is required (Two if you want to use DebugIt!Γäó).
What Gets Compiled Into 68000 Machine Code: Get, Put, all forms of Repeat, Next (repeat), all forms of If-Then-Else, Abs, Add, Atan, Average, CharToNum, Cos, Delete, Divide, Exit, Exp, Exp1, Exp2, Global, Length, Ln, Ln1, Log2, Min, Max, Multiply, Number (chunks), NumToChar, Offset, Param, Params, ParamCount, Pass, Random, Result, Return, Round, Sin, Sqrt, Subtract, Tan, Trunc. HyperTalk Operators: Div, Mod, +, -, *, &, &&, ≥, ≤, =, ≠, <, >, And, Or, Not, Is Not, Is, /, ^. Other: Constants, Ordinals, Toolbox calls. Other language elements are also supported but become text callbacks (they won't go any faster).
ROM Toolbox Access: ROM calls are supported through extensions to HyperTalk. Currently, Inside MacintoshΓäó volume 1-6 (including System 7.0) is supported and additional symbols can be added through CompileIt's Custom Symbol Edit card. Pointers and handles are supported as are Pascal-like array subscripts. Some examples are:
Function CountRes resType
return CountResources (resType) -- countResources is a ROM call
end CountRes
Put 5 into aHandle@@.integerType[10] -- puts the number 5 into
-- the 10th integer at handle aHandle
Put 5 into integer 10 of handle aHandle -- does the same as above
-- but with automatic bounds checking
HyperCard Extended XCMD Interface: Fully supported. See the card in this stack entitled ΓÇ£What are xWindoids?ΓÇ¥ for information on how CompileIt! supports this wonderful new functionality in HyperCard 2.0.
Debugging: CompileIt! includes a built-in source level debugger called DebugIt!. See the card in this stack entitled ΓÇ£What is DebugIt!?ΓÇ¥ for more information on this powerful feature.
Other: Background compiling under MultiFinder is supported. A comprehensive user manual is included.</text>
</content>
<name>CompileIt</name>
<script></script>
</card>
card_3163.xml
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE card PUBLIC "-//Apple, Inc.//DTD card V 2.0//EN" "" >
Answer "Convert 'abc ABC' to upper or lower case?"¬
with "Cancel" or "Upper" or "Lower"
if it is "Upper" then put 1 into case
else if it is "Lower" then put 2 into case
if case is not empty then
put LetterCase (case,var) into ans
go to this card
answer ans
end if
put false into HyperDebugIt
end mouseUp
</script>
</part>
<content>
<layer>background</layer>
<id>7</id>
<text>
Being able to compile scripts into externals is wonderful but how do you find errors and optimize your code? The answer is DebugIt!Γäó ΓÇö a source level debugger for CompileIt! created externals.
When you compile a script with the DebugIt! option turned on, special code is added to your external along with the text of the script being compiled. This special code is DebugIt!. When you run the external, DebugIt! opens a debugging window where you can see the original script and information about the variables used in the script. Using the controls in the debugging window you can execute the external a line at a time and see how the variables change, edit the values of variables, adjust how many times a repeat loop executes, and much more.
The entire debugger, customized for your script, is attached to externals compiled with this option on. This allows you to test your externals in ΓÇ£contextΓÇ¥ ΓÇö there is no need for a special debugging shell or even that CompileIt! be available. DebugIt! is compatible with HyperCard 1.2.5 and HyperCard 2.x as well as SuperCard 1.5 and other environments that support HyperCard externals.
The DebugIt! option is disabled in the Working Model but an external that has DebugIt! attached is in this stack. Clicking on the ΓÇ£DebugIt! DemoΓÇ¥ button above will call it. Try it now, play with the controls to see what they do, click on the the variables to change their values, click on the repeat loop counter to change the number of times the loop executes, etc. When you are finished exploring DebugIt!ΓÇÖs features, we think you'll agree that it is a tremendous time-saver and a valuable part of the CompileIt! 2.0 development system.
You'll find additional documentation on DebugIt! in the on-line help in the Working Model.
Features for Advanced Users:
If your external uses pointers or handles, a RAM editor will also be available. With the RAM editor you can view and edit the contents of the memory at your pointer or handle. The editor shows both hex and ascii values and has a revert button incase you make a mistake in your editing.
Clicking on a line displays an analysis of that line above the variable monitor. The analysis shows the total number of bytes the machine code takes up for that line and lists binary callbacks, text callbacks, number conversions, etc. This information is useful in optimizing your code for both speed and efficiency.
The ΓÇ£Review Text CallbacksΓÇ¥ and ΓÇ£Review Binary CallbacksΓÇ¥ checkboxes are used to monitor communications between your external and HyperCard. Callback request codes and results are displayed for binary callbacks. With text callbacks, you can edit both the callback text and the return result.</text>
</content>
<name>DebugIt</name>
<script></script>
</card>
card_4739.xml
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE card PUBLIC "-//Apple, Inc.//DTD card V 2.0//EN" "" >
HyperCard 2.0 introduced a new set of extensions for externals. These extensions allow externals to put up windows which behave as if they were HyperCard's windows (like the floating tool palette, the message box, and the script editor). These windows can have their own properties which are available from scripts, receive events like mousedowns, and have access to many features of HyperCard not previously available (like the text edit record of a field). You can even use these extensions to create replacements for the script editor if you want. Externals that take advantage of these extensions are called xWindoids. CompileIt! 2.0 fully supports these extensions and simplifies their use in several ways.
If you are using HyperCard 2.x, click on the button ΓÇ£xWindoid DemoΓÇ¥ above to see a simple xWindoid that displays a PICT resource. The demo window has several properties associated with it which are:
1. Name (set only) -- the name in the title bar of the window
2. Beeper (set or get) -- if true, beep sounds about every 5 seconds
3. Loc (set or get) -- the location of the window
4. Visible (set or get) -- whether the window is visible or not
Once you click on the xWindoid Demo button, try typing the following lines into the message box (show the message box by typing command-M or by choosing ΓÇ£MessageΓÇ¥ from the ΓÇ£GoΓÇ¥ menu):
set the name of window "Demo xWindoid" to "Demo"
put the loc of window "Demo"
set the beeper of window "Demo" to true
When you are done, click on the close box of the window to close it. A technical discussion of how to create xWindoids with CompileIt! is beyond the scope of this demo stack. The working model is limited to compiling scripts of 10 lines or less so you cannot create xWindoids with it but the on-line help has some additional information available for reference. The source code for the demo xWindoid in this stack is shown below.
Source Code for Demo xWindoid:
-- DemoXWindoid by BRM
global arect:Rect -- shared global variable of type rect
on DemoXWindoid x1,y1,x2,y2,pictName,winName -- create window
if x1 is "?" then return "DemoXWindoid x1,y1,x2,y2,pictName[,windowName]"
if first char of the version is not "2" then return "!! HyperCard 2.x required"
if x1 is empty or y1 is empty or x2 is empty or y2 is empty
then return "!! Rect undefined"
if pictName is not empty then put GetNamedResource("PICT",pictName) into myHandle
else return "!! PICT name required"
if myHandle is nil then return "!! Could not find PICT"
DetachResource myHandle -- take control of handle
if winName is empty then put "Untitled" into winName
if x1+0≥x2 then -- use picture rect
put myHandle@@.picframe.topLeft into arect.topleft
put myHandle@@.picframe.botRight into arect.botRight
Heizer Software offers a suite of HyperCard developer tools under the Heizer Select Series label. CompileIt!, WindowScript, and MasterScript are the core of the Heizer Select Series. Individually, each of these products fills an important need HyperCard developers have:
ΓÇó CompileIt!ΓÇöThe XCMD Development System
Created by Tom Pittman and awarded 5 mice by MacUser (Feb 1992)
Speed, Toolbox Access
ΓÇó WindowScriptΓÇöThe Interface Design Studio
Created by Leonard Buck of Dialoger Professional fame
Interface Design, Color, and QuickTime movies
ΓÇó MasterScriptΓÇöThe Professional Script Editor/Debugger
Created by Peter Nagel of HyperTMON fame
Script Editing, Debugging
Together with HyperCard, these tools make a complete development environment that's both powerful and easy to use.
All prices mentioned below are subject to change after 12/31/92. After that date you should call first to confirm pricing.
CompileIt!, the first HyperTalk compiler, is a complete development system for the creation of external commands and functions (XCMDs/XFCNs). Expand the capabilities of HyperCard, speed-up slow scripts, protect sensitive scripts, learn Macintosh programming!
CompileIt! is an essential tool in any HyperCard developer's toolkit. The combination of CompileIt! and HyperCard offer all the power and versatility for prototyping applications, creating custom solutions, and just plain having fun with your Macintosh!
Available Now. Only $149 (program no. 30-0521)
ΓÇ£Makes...creating XCMDs and XFCNs accessible to anyone who's
WindowScript is a tool for the design of Macintosh user-interfaces within HyperCard. In the past there were HyperCard stacks and Macintosh applications ΓÇö each with its own distinctive objects and feel. WindowScript finally brings to HyperCard the look and feel of a real Macintosh user-interface.
With WindowScript, HyperCard developers can create modal dialog boxes, modeless windows, floating palettes, even moveable modal dialog boxes. Each window or dialog box can contain any number of objects such as QuickTime movies, scrolling lists (including graphical lists of pictures and icons), custom menus (including tear off menus and pop-up menus), text fields with multiple fonts and styles and even colored text, icons and finder icons, color pictures, lines, boxes, and much more. And everything can be in full color!
MasterScript - The Professional Script Editor/Debugger
MasterScript is a script editor and source-level debugger designed for intermediate and advanced developers of Claris HyperCard. In addition to the editing and debugging features HyperCard developers have come to expect, MasterScript adds sophisticated features such as the Externals Monitor (for monitoring XCMD callbacks, parameter blocks, and external window events), and GREP searching (searching for patterns of words, letters, and numbers with very fine control), without sacrificing simplicity and accessibility. Master the fine art of HyperTalk programming with MasterScript!
Available Now. Only $129 (program no. 30-0519)
ΓÇ£At last! A HyperTalk editor for professional program designΓÇ¥
Andrew Meit, HyperCard Developer
Richardson, TX</text>
</content>
<content>
<layer>card</layer>
<id>5</id>
<text>Order Line
800-888-7667</text>
</content>
<name>heizer</name>
<script></script>
</card>
card_5880.xml
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE card PUBLIC "-//Apple, Inc.//DTD card V 2.0//EN" "" >
Please include $3 (US & Canada) or $7 (international) shipping/handling and for California residents, appropriate sales tax for your county. Please specify program number when ordering.</text>
</content>
<content>
<layer>card</layer>
<id>3</id>
<text>Order Line
800-888-7667</text>
</content>
<name>ordering</name>
<script></script>
</card>
card_7184.xml
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE card PUBLIC "-//Apple, Inc.//DTD card V 2.0//EN" "" >
